home *** CD-ROM | disk | FTP | other *** search
/ Almathera Ten Pack 3: CDPD 3 / Almathera Ten on Ten - Disc 3: CDPD3.iso / ab20 / unarced / utilities / system / intuition / shadow / examples / browser / browser.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-03-17  |  71.3 KB  |  2,338 lines

  1. /*
  2.  * Browser Program.
  3.  *
  4.  * å© Copyright 1991, ALl Rights Reserved
  5.  *
  6.  *  David C. Navas
  7.  */
  8. #include <shadow/coreMeta.h>
  9. #include <shadow/coreRoot.h>
  10. #include <shadow/process.h>
  11. #include <shadow/semaphore.h>
  12.  
  13. /*
  14.  * Strings have to be word-aligned -- so add the space at the end,
  15.  * just in case.
  16.  */
  17. #define GUITASK "Browser's Gui Task\0"
  18. #include "/Gui/gui.h"
  19.  
  20. #include <ipc.h>
  21. #include <shadow/shadow_proto.h>
  22. #include <shadow/shadow_pragmas.h>
  23. #include <shadow/method.h>
  24. #include <dos/dostags.h>
  25.  
  26. extern struct ExecBase * __far SysBase;
  27. extern struct IntuitionBase * __far IntuitionBase;
  28. struct IPCBase * __far IPCBase;
  29. struct ShadowBase * __far ShadowBase;
  30. struct DosLibrary * __far DOSBase;
  31.  
  32. /*
  33.  * external class definitions.
  34.  */
  35. char GuiProcClassName[] = GUIPROCESSCLASS,
  36.      GuiTaskName[] = GUITASK,
  37.      GuiClassName[] = GUICLASS,
  38.      WindowClassName[] = WINDOWCLASS,
  39.      GadgTClassName[] = GADGTCLASS;
  40.  
  41. /*
  42.  * Global Variables (non-library).
  43.  */
  44. OBJECT __far GlobalDirector = NULL;
  45. struct SignalSemaphore programSemaphore;
  46. struct Task * __far programTask;
  47. long __far GlobalNumOpen = 0;
  48.  
  49. /*
  50.  * Function prototypes.
  51.  */
  52. void __regargs *addFromBinNodes(void *, ULONG, struct CWinLocalObjects *);
  53. void LoadBrowser(void);
  54.  
  55.  
  56. /*
  57.  * ==========================================================================
  58.  * =                                                                        =
  59.  * =            Class definition for the BlockClass.                        =
  60.  * =                                                                        =
  61.  * ==========================================================================
  62.  */
  63.  
  64. #define BLOCKCLASS   "Browser Class"
  65.  
  66. /*
  67.  * Attributes
  68.  */
  69. #define ATTR_BLOCKDIR "director"
  70.  
  71. ATTRIBUTE_TAG blockAttrs[] = {
  72.                                 ATTR_BLOCKDIR, 2 * sizeof(void *), NULL,
  73.                                 TAG_END
  74.                              };
  75.  
  76. /*
  77.  * Methods
  78.  */
  79. BOOL BlockInitMethod(METHOD_ARGS);
  80. void BlockRemoveMethod(METHOD_ARGS);
  81. void BlockNotifyMethod(METHOD_ARGS, long flags,
  82.                                        W_VALUE watcher,
  83.                                        void *first,
  84.                                        void *second,
  85.                                        OBJECT dispatch);
  86. METHOD_TAG blockMethods[] =
  87.                         {
  88.                            {
  89.                               METHOD_META_INIT,
  90.                               NULL, NULL,
  91.                               SHADOW_MSG_FORCE_SYNC,
  92.                               METHOD_FLAG_PROC, 0,
  93.                               (METHODFUNCTYPE)BlockInitMethod, NULL
  94.                            },
  95.                            {
  96.                               METHOD_META_REMOVE,
  97.                               NULL, NULL,
  98.                               SHADOW_MSG_FORCE_SYNC,
  99.                               METHOD_FLAG_PROC, 0,
  100.                               (METHODFUNCTYPE)BlockRemoveMethod, NULL
  101.                            },
  102.                            {
  103.                               METHOD_DIRECTOR_NOTIFY,
  104.                               NULL, NULL,
  105.                               SHADOW_MSG_FORCE_ASYNC,
  106.                               METHOD_FLAG_PROC, 0,
  107.                               (METHODFUNCTYPE)BlockNotifyMethod,
  108.                                  REF_NODENOTIFY
  109.                            },
  110.                            TAG_END
  111.                         };
  112.  
  113.  
  114. /*
  115.  * ==========================================================================
  116.  * =                                                                        =
  117.  * =       Class definition for the Class Display Window Class.             =
  118.  * =                                                                        =
  119.  * ==========================================================================
  120.  */
  121.  
  122. #define CWINCLASS "Window subClass that shows JOBJs"
  123.  
  124. /*
  125.  * Attributes
  126.  */
  127. #define ATTR_LOCALWIN "local objects"
  128.  
  129. struct MyNode {
  130.    struct Node node;
  131.    void *object;
  132. };
  133.  
  134. struct CWinLocalObjects {
  135.    struct MyNode     *lastNode,
  136.                      *nodes;
  137.    struct List       list;
  138.    OBJECT            listObject,
  139.                      object1,
  140.                      object2,
  141.                      object3,
  142.                      object4;
  143.    char              *superClassText;
  144.    OBJECT            director;
  145.    struct MemoryList myMemList;
  146.    META              meta;
  147. };
  148.  
  149. ATTRIBUTE_TAG CWinAttrs[] =
  150.                         {
  151.                            {ATTR_LOCALWIN, sizeof(struct CWinLocalObjects),
  152.                                            NULL},
  153.                            {TAG_END}
  154.                         };
  155.  
  156. /*
  157.  * MethodRefs
  158.  */
  159. extern METHOD_REF REF_CWinInitMethod[], REF_CWinHitMethod[];
  160.  
  161. /*
  162.  * Methods
  163.  */
  164. void CWinHitMethod(METHOD_ARGS, long code);
  165. void *CWinInitMethod(METHOD_ARGS, OBJECT parent,
  166.                                   META   meta);
  167. void CWinRemoveMethod(METHOD_ARGS);
  168. void CWinDestroyMethod(METHOD_ARGS);
  169.  
  170. #define METHOD_GADGET_OPEN_MWIN  "open method display window"
  171. #define METHOD_GADGET_OPEN_AWIN  "open attr display window"
  172. #define METHOD_GADGET_OPEN_OWIN  "open object display"
  173.  
  174. void CWinOpenMWinMethod(METHOD_ARGS);
  175. void CWinOpenAWinMethod(METHOD_ARGS);
  176. void CWinOpenOWinMethod(METHOD_ARGS);
  177.  
  178. void CWinNotifyMethod(METHOD_ARGS, long flags,
  179.                                        W_VALUE watcher,
  180.                                        void *first,
  181.                                        void *second);
  182.  
  183. METHOD_TAG CWinMethods[] =
  184.                         {
  185.                            {
  186.                               METHOD_META_INIT,
  187.                               NULL, NULL,
  188.                               SHADOW_MSG_SYNC,
  189.                               METHOD_FLAG_PROC, 0,
  190.                               CWinInitMethod, REF_CWinInitMethod
  191.                            },
  192.                            {
  193.                               METHOD_META_DESTROY,
  194.                               NULL, NULL,
  195.                               SHADOW_MSG_SYNC,
  196.                               METHOD_FLAG_PROC, 0,
  197.                               (METHODFUNCTYPE)CWinDestroyMethod, NULL
  198.                            },
  199.                            {
  200.                               METHOD_META_REMOVE,
  201.                               NULL, NULL,
  202.                               SHADOW_MSG_SYNC,
  203.                               METHOD_FLAG_PROC, 0,
  204.                               (METHODFUNCTYPE)CWinRemoveMethod, NULL
  205.                            },
  206.                            {
  207.                               METHOD_GADGET_SELECT,
  208.                               NULL, NULL,
  209.                               SHADOW_MSG_CALL,
  210.                               METHOD_FLAG_PROC, 0,
  211.                               (METHODFUNCTYPE)CWinHitMethod,
  212.                                  REF_CWinHitMethod
  213.                            },
  214.                            {
  215.                               METHOD_GADGET_OPEN_MWIN,
  216.                               NULL, NULL,
  217.                               SHADOW_MSG_CALL,
  218.                               METHOD_FLAG_PROC, 0,
  219.                               (METHODFUNCTYPE)CWinOpenMWinMethod, NULL
  220.                            },
  221.                            {
  222.                               METHOD_GADGET_OPEN_AWIN,
  223.                               NULL, NULL,
  224.                               SHADOW_MSG_CALL,
  225.                               METHOD_FLAG_PROC, 0,
  226.                               (METHODFUNCTYPE)CWinOpenAWinMethod, NULL
  227.                            },
  228.                            {
  229.                               METHOD_GADGET_OPEN_OWIN,
  230.                               NULL, NULL,
  231.                               SHADOW_MSG_CALL,
  232.                               METHOD_FLAG_PROC, 0,
  233.                               (METHODFUNCTYPE)CWinOpenOWinMethod, NULL
  234.                            },
  235.                            {
  236.                               METHOD_DIRECTOR_NOTIFY,
  237.                               NULL, NULL,
  238.                               SHADOW_MSG_SYNC,
  239.                               METHOD_FLAG_PROC, 0,
  240.                               (METHODFUNCTYPE)CWinNotifyMethod,
  241.                                  REF_NODENOTIFY
  242.                            },
  243.                            TAG_END
  244.                         };
  245.  
  246. /*
  247.  * ==========================================================================
  248.  * =                                                                        =
  249.  * =       Class definition for the Method Display Window Class.            =
  250.  * =                                                                        =
  251.  * ==========================================================================
  252.  */
  253.  
  254. #define METWINCLASS "Window subClass that shows Methods"
  255.  
  256. /*
  257.  * Attributes
  258.  */
  259. struct MWinLocalObjects {
  260.    struct MyNode  *lastNode,
  261.                   *nodes;
  262.    struct List    list;
  263.    OBJECT         object1,
  264.                   object2,
  265.                   object3,
  266.                   object4,
  267.                   object5,
  268.                   director;
  269.    CLASS          class;
  270. };
  271.  
  272. ATTRIBUTE_TAG MetWinAttrs[] =
  273.                         {
  274.                            {ATTR_LOCALWIN, sizeof(struct MWinLocalObjects),
  275.                                            NULL},
  276.                            {TAG_END}
  277.                         };
  278.  
  279. /*
  280.  * MethodRefs
  281.  */
  282. extern METHOD_REF REF_MetWinInitMethod[], REF_MetWinHitMethod[],
  283.                   REF_MWinOpenRWinMethod[];
  284.  
  285. /*
  286.  * Methods
  287.  */
  288. void MetWinUpdateInfo(METHOD_ARGS);
  289. void MetWinHitMethod(METHOD_ARGS, long code);
  290. void *MetWinInitMethod(METHOD_ARGS, OBJECT parent,
  291.                                     CLASS);
  292. void MetWinDestroyMethod(METHOD_ARGS);
  293. void MetWinRemoveMethod(METHOD_ARGS);
  294.  
  295. void MWinOpenRWinMethod(METHOD_ARGS);
  296.  
  297. #define METHOD_GADGET_OPEN_RWIN "open argument display window"
  298. #define METHOD_METHOD_UPDATE_INFO "Update Info in Method Window"
  299.  
  300. METHOD_TAG  MetWinMethods[] =
  301.                         {
  302.                            {
  303.                               METHOD_META_INIT,
  304.                               NULL, NULL,
  305.                               SHADOW_MSG_SYNC,
  306.                               METHOD_FLAG_PROC, 0,
  307.                               MetWinInitMethod, REF_MetWinInitMethod
  308.                            },
  309.                            {
  310.                               METHOD_META_DESTROY,
  311.                               NULL, NULL,
  312.                               SHADOW_MSG_SYNC,
  313.                               METHOD_FLAG_PROC, 0,
  314.                               (METHODFUNCTYPE)MetWinDestroyMethod, NULL
  315.                            },
  316.                            {
  317.                               METHOD_META_REMOVE,
  318.                               NULL, NULL,
  319.                               SHADOW_MSG_SYNC,
  320.                               METHOD_FLAG_PROC, 0,
  321.                               (METHODFUNCTYPE)MetWinRemoveMethod, NULL
  322.                            },
  323.                            {
  324.                               METHOD_GADGET_SELECT,
  325.                               NULL, NULL,
  326.                               SHADOW_MSG_CALL,
  327.                               METHOD_FLAG_PROC, 0,
  328.                               (METHODFUNCTYPE)MetWinHitMethod,
  329.                                  REF_MetWinHitMethod
  330.                            },
  331.                            {
  332.                               METHOD_GADGET_OPEN_RWIN,
  333.                               NULL, NULL,
  334.                               SHADOW_MSG_CALL,
  335.                               METHOD_FLAG_PROC, 0,
  336.                               (METHODFUNCTYPE)MWinOpenRWinMethod, NULL
  337.                            },
  338.                            {
  339.                               METHOD_METHOD_UPDATE_INFO,
  340.                               NULL, NULL,
  341.                               SHADOW_MSG_SYNC,
  342.                               METHOD_FLAG_PROC, 0,
  343.                               (METHODFUNCTYPE)MetWinUpdateInfo, NULL
  344.                            },
  345.                            TAG_END
  346.                         };
  347.  
  348.  
  349. /*
  350.  * ==========================================================================
  351.  * =                                                                        =
  352.  * =     Class definition for the Attribute Display Window Class.           =
  353.  * =                                                                        =
  354.  * ==========================================================================
  355.  */
  356.  
  357. #define ATTWINCLASS "Window subClass that shows Attributes"
  358.  
  359. /*
  360.  * Attributes
  361.  */
  362. struct AWinLocalObjects {
  363.    struct MyNode *lastNode,
  364.                  *nodes;
  365.    struct List   list;
  366.    OBJECT        object1,
  367.                  object2,
  368.                  object3,
  369.                  object4;
  370.    META          meta;
  371. };
  372.  
  373. ATTRIBUTE_TAG AttWinAttrs[] =
  374.                         {
  375.                            {ATTR_LOCALWIN, sizeof(struct AWinLocalObjects),
  376.                                            NULL},
  377.                            {TAG_END}
  378.                         };
  379.  
  380. /*
  381.  * MethodRefs
  382.  */
  383. extern METHOD_REF REF_AttWinInitMethod[], REF_AttWinHitMethod[];
  384.  
  385. /*
  386.  * Methods
  387.  */
  388. void AttWinHitMethod(METHOD_ARGS, long code);
  389. void *AttWinInitMethod(METHOD_ARGS, OBJECT parent, CLASS);
  390. void AttWinDestroyMethod(METHOD_ARGS);
  391.  
  392. METHOD_TAG AttWinMethods[] =
  393.                         {
  394.                            {
  395.                               METHOD_META_INIT,
  396.                               NULL, NULL,
  397.                               SHADOW_MSG_SYNC,
  398.                               METHOD_FLAG_PROC, 0,
  399.                               AttWinInitMethod, REF_AttWinInitMethod
  400.                            },
  401.                            {
  402.                               METHOD_META_DESTROY,
  403.                               NULL, NULL,
  404.                               SHADOW_MSG_SYNC,
  405.                               METHOD_FLAG_PROC, 0,
  406.                               (METHODFUNCTYPE)AttWinDestroyMethod, NULL
  407.                            },
  408.                            {
  409.                               METHOD_GADGET_SELECT,
  410.                               NULL, NULL,
  411.                               SHADOW_MSG_CALL,
  412.                               METHOD_FLAG_PROC, 0,
  413.                               (METHODFUNCTYPE)AttWinHitMethod,
  414.                                  REF_AttWinHitMethod
  415.                            },
  416.                            TAG_END
  417.                         };
  418.  
  419.  
  420. /*
  421.  * ==========================================================================
  422.  * =                                                                        =
  423.  * =     Class definition for the MethodRef Display Window Class.           =
  424.  * =                                                                        =
  425.  * ==========================================================================
  426.  */
  427.  
  428. #define REFWINCLASS "Window subClass that shows MethodRefs"
  429.  
  430. /*
  431.  * Attributes
  432.  */
  433. struct RWinLocalObjects {
  434.    struct MyNode  *lastNode,
  435.                   *nodes;
  436.    struct List    list;
  437.    OBJECT         object1,
  438.                   object2;
  439.    char           *text;
  440. };
  441.  
  442. ATTRIBUTE_TAG RefWinAttrs[] =
  443.                         {
  444.                            {ATTR_LOCALWIN, sizeof(struct RWinLocalObjects),
  445.                                            NULL},
  446.                            {TAG_END}
  447.                         };
  448.  
  449. /*
  450.  * MethodRefs
  451.  */
  452. extern METHOD_REF REF_RefWinInitMethod[], REF_RefWinHitMethod[];
  453.  
  454. /*
  455.  * Methods
  456.  */
  457. void RefWinHitMethod(METHOD_ARGS, long code);
  458. void *RefWinInitMethod(METHOD_ARGS, OBJECT parent,
  459.                                     struct MethodHandler *,
  460.                                     CLASS  mclass);
  461. void RefWinDestroyMethod(METHOD_ARGS);
  462.  
  463. METHOD_TAG RefWinMethods[] =
  464.                         {
  465.                            {
  466.                               METHOD_META_INIT,
  467.                               NULL, NULL,
  468.                               SHADOW_MSG_SYNC,
  469.                               METHOD_FLAG_PROC, 0,
  470.                               RefWinInitMethod, REF_RefWinInitMethod
  471.                            },
  472.                            {
  473.                               METHOD_META_DESTROY,
  474.                               NULL, NULL,
  475.                               SHADOW_MSG_SYNC,
  476.                               METHOD_FLAG_PROC, 0,
  477.                               (METHODFUNCTYPE)RefWinDestroyMethod, NULL
  478.                            },
  479.                            {
  480.                               METHOD_GADGET_SELECT,
  481.                               NULL, NULL,
  482.                               SHADOW_MSG_CALL,
  483.                               METHOD_FLAG_PROC, 0,
  484.                               (METHODFUNCTYPE)RefWinHitMethod,
  485.                                  REF_RefWinHitMethod
  486.                            },
  487.                            TAG_END
  488.                         };
  489.  
  490.  
  491. /*
  492.  * ==========================================================================
  493.  * =                                                                        =
  494.  * =                    F  U  N  C  T  I  O  N  S                           =
  495.  * =                                                                        =
  496.  * ==========================================================================
  497.  */
  498.  
  499. /*
  500.  * ^C -- just say no.
  501.  */
  502. int CXBRK(void)
  503. {
  504.    return(0);
  505. }
  506.  
  507. /*
  508.  * no!
  509.  */
  510. chkabort(void)
  511. {
  512.    return(0);
  513. }
  514.  
  515. /*
  516.  * Okay, here's the main.
  517.  */
  518. void main(void)
  519. {
  520.  
  521.    programTask = FindTask(NULL);
  522.  
  523.    /*
  524.     * Open Libraries and startup the program for SHADOW.
  525.     */
  526.    InitSemaphore(&programSemaphore);
  527.  
  528.    if (DOSBase = (struct DosLibrary *)OpenLibrary("dos.library", 37))
  529.    {
  530.       if (IPCBase = OpenLibrary("ppipc.library", 0))
  531.       {
  532.  
  533.          if (ShadowBase = (struct ShadowBase *)
  534.                           OpenLibrary("shadow.library", 4))
  535.          {
  536.  
  537.             if (InitOOProgram("Browser Program"))
  538.             {
  539.  
  540.                /*
  541.                 * Okay, run the Browser.
  542.                 */
  543.                LoadBrowser();
  544.                RemoveCurrentProgram(&programSemaphore);
  545.             } else
  546.                VPrintf("Can't init Browser program.\n", NULL);
  547.  
  548.             CloseLibrary(ShadowBase);
  549.          } else
  550.             VPrintf("requires shadow.library 4.3 in libs:\n", NULL);
  551.  
  552.          CloseLibrary(IPCBase);
  553.       } else
  554.          VPrintf("requires ppipc.library in libs:\n", NULL);
  555.    } else
  556.    {
  557.       DOSBase = (struct DosLibrary *)OpenLibrary("dos.library", 0);
  558.       Write(Output(), "Sorry, use 2.0\n", 15);
  559.    }
  560.    CloseLibrary(DOSBase);
  561. }
  562.  
  563. void LoadBrowser(void)
  564. {
  565.    OBJECT    guiTask;
  566.    W_AVLTREE wbt;
  567.    int success;
  568.  
  569. #ifndef NDEBUG
  570.    ULONG args[10];
  571.    long mem2;
  572.  
  573.    args[0] = mem2 = AvailMem(MEMF_ANY);
  574. #endif
  575.  
  576.    /*
  577.     * Have we already started a browser ???
  578.     * if so, we can just send it a method and shut ourselves down.
  579.     */
  580.    if (CreateInstance(NULL, BLOCKCLASS, METACLASS, METHOD_END))
  581.       return;
  582.  
  583.    /*
  584.     * Initialize the GUI
  585.     */
  586.    success = InitGUISystem();
  587.  
  588. #ifndef NDEBUG
  589.    VPrintf("MemStart %ld\n", args);
  590. #endif
  591.  
  592.    if (wbt = FindAttribute(programTask->tc_UserData, ATTR_RESOURCETREE))
  593.       guiTask = FindStringInWatchedBinTree(wbt, GUITASK);
  594.    else
  595.       guiTask = NULL;
  596.  
  597.    SetupMethodTags(CWinMethods, guiTask, (void *)-1);
  598.    SetupMethodTags(MetWinMethods, guiTask, (void *)-1);
  599.    SetupMethodTags(AttWinMethods, guiTask, (void *)-1);
  600.    SetupMethodTags(RefWinMethods, guiTask, (void *)-1);
  601.    SetupMethodTags(blockMethods, guiTask, (void *)-1);
  602.  
  603.    DropObject(guiTask);
  604.  
  605.    /*
  606.     * Create BlockClass.
  607.     */
  608.  
  609.    success &= AddAutoResource(NULL,
  610.                               CreateSubClass(NULL,
  611.                                              GUICLASS,
  612.                                              METACLASS,
  613.                                              BLOCKCLASS,
  614.                                              NULL,
  615.                                              blockAttrs,
  616.                                              blockMethods,
  617.                                              METHOD_END),
  618.                               BLOCKCLASS);
  619.  
  620.    /*
  621.     * Create the window classes.
  622.     */
  623.    success &= AddAutoResource(NULL,
  624.                               CreateSubClass(NULL,
  625.                                             WINDOWCLASS,
  626.                                             METACLASS,
  627.                                             CWINCLASS,
  628.                                             NULL,
  629.                                             CWinAttrs,
  630.                                             CWinMethods,
  631.                                             METHOD_END),
  632.                               CWINCLASS);
  633.  
  634.    success &= AddAutoResource(NULL,
  635.                               CreateSubClass(NULL,
  636.                                              WINDOWCLASS,
  637.                                              METACLASS,
  638.                                              METWINCLASS,
  639.                                              NULL,
  640.                                              MetWinAttrs,
  641.                                              MetWinMethods,
  642.                                              METHOD_END),
  643.                               METWINCLASS);
  644.  
  645.    success &= AddAutoResource(NULL,
  646.                               CreateSubClass(NULL,
  647.                                              WINDOWCLASS,
  648.                                              METACLASS,
  649.                                              ATTWINCLASS,
  650.                                              NULL,
  651.                                              AttWinAttrs,
  652.                                              AttWinMethods,
  653.                                              METHOD_END),
  654.                               ATTWINCLASS);
  655.  
  656.    success &= AddAutoResource(NULL,
  657.                               CreateSubClass(NULL,
  658.                                              WINDOWCLASS,
  659.                                              METACLASS,
  660.                                              REFWINCLASS,
  661.                                              NULL,
  662.                                              RefWinAttrs,
  663.                                              RefWinMethods,
  664.                                              METHOD_END),
  665.                               REFWINCLASS);
  666.  
  667.    /*
  668.     * Create the top level window.
  669.     */
  670.    success &= (BOOL)CreateInstance(NULL, BLOCKCLASS, METACLASS, METHOD_END);
  671.  
  672.  
  673. #ifndef NDEBUG
  674.    args[0] = mem2 - AvailMem(MEMF_ANY);
  675.  
  676.    VPrintf("Memory Usage %ld\n", args);
  677. #endif
  678.  
  679.  
  680.    /*
  681.     * basically Wait for everything to shut down.
  682.     *
  683.     * Nothing is actually going to use these ports, but they ARE
  684.     *  allocated, so I might as well use them.
  685.     */
  686.    if (success)
  687.       HandleMessages(programTask);
  688.  
  689. #ifndef NDEBUG
  690.    args[0] = AvailMem(MEMF_ANY);
  691.    VPrintf("MemEnd %ld\n", args);
  692. #endif
  693. }
  694.  
  695.  
  696. /*
  697.  * Add all of the objects into the list....
  698.  */
  699. void __regargs *addFromBinNodes(void *value,
  700.                                 ULONG name,
  701.                                 struct CWinLocalObjects *local)
  702. {
  703.    struct MyNode *node;
  704.  
  705.    if (!(node = AllocateItem(&local->myMemList)))
  706.       return (void *)-1;
  707.  
  708.    if (name == (long)value)
  709.    {
  710.       char buffer[20];
  711.       long name2;
  712.  
  713.       name2 = name;
  714.  
  715.       RawDoFmt("Object at: %lx", &name2, SprintfCallback, buffer);
  716.       node->node.ln_Name = UseString(buffer);
  717.    }
  718.    else
  719.       node->node.ln_Name = UseString((char *)name);
  720.  
  721.    /*
  722.     * The object might reference this CWindow.
  723.     *  THEREFORE, it hangs, unless reference removed during remove
  724.     *   method, as opposed to DESTROY method.
  725.     *   [Because DESTROY would never get called, it self-references.]
  726.     */
  727.  
  728.    node->object = value;
  729.    UseObject(value);
  730.  
  731.    AddTail(&local->list, node);
  732.    return NULL;
  733. }
  734.  
  735.  
  736. /*
  737.  * ==========================================================================
  738.  * =                                                                        =
  739.  * =            ALL OF THE CLASS METHODS ARE BELOW.                         =
  740.  * =                                                                        =
  741.  * ==========================================================================
  742.  */
  743.  
  744. /*
  745.  * Block Class methods.
  746.  */
  747. BOOL BlockInitMethod(METHOD_ARGS)
  748. {
  749.    OBJECT *director, handle;
  750.  
  751.    director = FindAttribute(object, ATTR_BLOCKDIR);
  752.  
  753.    if (CallSuper())
  754.    {
  755.       OBJECT window;
  756.       CLASS  windowClass;
  757.  
  758.       /*
  759.        * Create the example Global Director which watches all of the
  760.        *  window classes' GUICHILDREN attribute.
  761.        */
  762.       if (!GlobalDirector)
  763.       {
  764.          /*
  765.           * Get a director object.
  766.           */
  767.          GlobalDirector = CreateInstance(NULL,
  768.                                          DIRECTORCLASS,
  769.                                          METACLASS,
  770.                                          "WatchWindows",
  771.                                          object,
  772.                                          METHOD_DIRECTOR_NOTIFY,
  773.                                          (W_INSERT_NODE | W_REMOVE) |
  774.                                            (SHADOW_CLASS << 16) |
  775.                                            W_FLAG_AUTOBREAK  |
  776.                                            W_FLAG_AUTOREMOVE,
  777.                                          METHOD_END);
  778.  
  779.          /*
  780.           * Establish the actual connection.  We don't care if
  781.           * it doesn't actually Open, so that makes things easier.
  782.           *
  783.           * We are watching all the ATTR_GUICHILDREN of every instance
  784.           *  whose class is a subclass of WINDOWCLASS
  785.           */
  786.          windowClass = FindJazzClass(WINDOWCLASS);
  787.          DropObject(DoJazzMethod(GlobalDirector,
  788.                                  NULL,
  789.                                  METHOD_DIRECTOR_ESTABLISH,
  790.                                  ATTR_GUICHILDREN,
  791.                                  windowClass,
  792.                                  METHOD_END));
  793.          DropObject(windowClass);
  794.  
  795.          /*
  796.           * Why is this at priority one?
  797.           * Well, there's this race condition....  You can either shut
  798.           *  this down FIRST, or you can make the notification in
  799.           *  CWIN ASYNC.  I like this better.
  800.           */
  801.          AddAutoResource(programTask->tc_UserData, GlobalDirector, (char *)1);
  802.       }
  803.  
  804.  
  805.       /*
  806.        * Create the director to watch the children of this object.
  807.        *
  808.        * When this object's children reaches zero, this object
  809.        *  should GO AWAY!
  810.        */
  811.  
  812.       *director = CreateInstance(NULL,
  813.                                  DIRECTORCLASS,
  814.                                  METACLASS,
  815.                                  "WatchBlockedChildren",
  816.                                  object,
  817.                                  METHOD_DIRECTOR_NOTIFY,
  818.                                  (W_INSERT_NODE | W_REMOVE) |
  819.                                    (SHADOW_OBJECT << 16) |
  820.                                    W_FLAG_AUTOBREAK |
  821.                                    W_FLAG_AUTOREMOVE,
  822.                                  METHOD_END);
  823.       /*
  824.        * Establish the conection for the director.
  825.        */
  826.       if (handle = DoJazzMethod(*director, NULL, METHOD_DIRECTOR_ESTABLISH,
  827.                                         ATTR_GUICHILDREN,
  828.                                         object,
  829.                                         METHOD_END))
  830.       {
  831.          DropObject(handle);
  832.          if (window = CreateInstance(NULL,
  833.                                      CWINCLASS,
  834.                                      METACLASS,
  835.                                      object,
  836.                                      METHOD_END))
  837.          {
  838.             DropObject(window);
  839.             if (AddAutoResource(programTask->tc_UserData, object, NULL))
  840.             {
  841.                GlobalNumOpen++;
  842.                return TRUE;
  843.             }
  844.          }
  845.       }
  846.       RemoveObject(object);
  847.    }
  848.    return FALSE;
  849. }
  850.  
  851. void BlockRemoveMethod(METHOD_ARGS)
  852. {
  853.    OBJECT director;
  854.  
  855.    DropObject(RemoveAutoResource(programTask->tc_UserData, object, NULL));
  856.  
  857.    director = SetObject(FindAttribute(object, ATTR_BLOCKDIR), NULL);
  858.    RemoveObject(director);
  859.  
  860.    CallSuper();
  861.  
  862.    if (!--GlobalNumOpen)
  863.       Signal(programTask, SIGBREAKF_CTRL_C);
  864. }
  865.  
  866. void BlockNotifyMethod(METHOD_ARGS, long flags,
  867.                                        W_VALUE  watcher,
  868.                                        void *first,
  869.                                        void *second,
  870.                                        OBJECT dispatch)
  871. {
  872.    long *director;
  873.  
  874.    director = FindAttribute(object, ATTR_BLOCKDIR);
  875.    if (!second)  second = "";
  876.  
  877.    if (dispatch == GlobalDirector)
  878.    {
  879.       if (flags & W_INSERT)
  880.       {
  881.          VPrintf("Inserted child <%s> into some Window Object.\n",
  882.                   (ULONG *)&second);
  883.       } else
  884.       {
  885.          VPrintf("Removed child <%s> from some Window Object.\n",
  886.                   (ULONG *)&second);
  887.       }
  888.    } else
  889.    {
  890.       if (flags & W_INSERT)
  891.          (director[1])++;
  892.       else if (!(--(director[1])))
  893.       {
  894.          RemoveObject(UseObject(object));
  895.       }
  896.    }
  897. }
  898.  
  899. /*
  900.  * CWin Class methods.
  901.  */
  902. METHOD_REF REF_CWinInitMethod[] = {
  903.                                      {'JOBJ', sizeof(void *), SHADOW_OBJECT},
  904.                                      {'JOBJ', sizeof(void *), SHADOW_CLASS},
  905.                                      {TAG_END, SHADOW_RETURN_OBJECT, 0}
  906.                                   };
  907. void *CWinInitMethod(METHOD_ARGS, OBJECT parent,
  908.                                   META meta)
  909. {
  910.    struct CWinLocalObjects *mlo;
  911.  
  912.    mlo = FindAttribute(object, ATTR_LOCALWIN);
  913.    NewList(&mlo->list);
  914.    if (!(InitTable(&mlo->myMemList, NULL, NULL, sizeof(struct MyNode))))
  915.    {
  916.       UseObject(object);
  917.       DropObject(object);
  918.       return NULL;
  919.    }
  920.  
  921.    /*
  922.     * Create the correct window with the correct title....
  923.     */
  924.    {
  925.       struct TagItem tag[8];
  926.       char *string;
  927.  
  928.       {
  929.          char buffer[128];
  930.  
  931.          if (!meta)
  932.             strcpy(buffer, "Meta list for system");
  933.          else if (meta->meta_class == meta)
  934.          {
  935.             strcpy(buffer, "Class list for: ");
  936.             strncat(buffer, meta->meta_name, 64);
  937.          } else
  938.          {
  939.             strcpy(buffer, "Object list for: ");
  940.             strncat(buffer, meta->meta_name, 64);
  941.          }
  942.          if (!(string = UseString(buffer)))
  943.          {
  944.             UseObject(object);
  945.             DropObject(object);
  946.             return NULL;
  947.          }
  948.       }
  949.  
  950.       tag[0].ti_Tag = WA_Width;
  951.       tag[0].ti_Data = 500;
  952.       tag[1].ti_Tag = WA_Height;
  953.       tag[1].ti_Data = 200;
  954.       tag[2].ti_Tag = WA_MinWidth;
  955.       tag[2].ti_Data = 60;
  956.       tag[3].ti_Tag = WA_MinHeight;
  957.       tag[3].ti_Data = 40;
  958.       tag[4].ti_Tag = WA_MaxWidth;
  959.       tag[4].ti_Data = -1;
  960.       tag[5].ti_Tag = WA_MaxHeight;
  961.       tag[5].ti_Data = -1;
  962.       tag[6].ti_Tag = WA_SimpleRefresh;
  963.       tag[6].ti_Data = TRUE;
  964.       tag[7].ti_Tag = TAG_END;
  965.  
  966.       object = DoJazzMethod(object, class->meta_superClass, METHOD_META_INIT,
  967.                                                  parent,
  968.                                                  string,
  969.                                                  NULL,
  970.                                                  NULL,
  971.                                                  tag, METHOD_END);
  972.       DropString(string);
  973.       if (!object)
  974.          return NULL;
  975.    }
  976.  
  977.    mlo->meta = UseObject(meta);
  978.  
  979.    /*
  980.     * So watch the tree....
  981.     */
  982.    /*
  983.     * Create the watching director object.
  984.     */
  985.    mlo->director = CreateInstance(NULL,
  986.                                   DIRECTORCLASS,
  987.                                   METACLASS,
  988.                                   "Watch Meta",
  989.                                   object,
  990.                                   METHOD_DIRECTOR_NOTIFY,
  991.                                   (W_INSERT_NODE | W_REMOVE) |
  992.                                     (SHADOW_OBJECT << 16) |
  993.                                     W_FLAG_AUTOBREAK |
  994.                                     W_FLAG_AUTOREMOVE,
  995.                                   METHOD_END);
  996.  
  997.    /*
  998.     * Establish the connection.
  999.     */
  1000.    DropObject( DoJazzMethod(mlo->director,
  1001.                             NULL,
  1002.                             METHOD_DIRECTOR_ESTABLISH,
  1003.                             (meta)?ATTR_OBJECTLIST:
  1004.                                   &ShadowBase->sb_metaTree,
  1005.                             meta,
  1006.                             METHOD_END));
  1007.  
  1008.  
  1009.    /*
  1010.     * Copy all the instance objects into the list.
  1011.     */
  1012.    {
  1013.       W_AVLTREE tree;
  1014.  
  1015.       tree = (meta)?FindAttribute(meta, "object list"):&ShadowBase->sb_metaTree;
  1016.       DoInOrderBinTree(&tree->wv_value, addFromBinNodes, mlo);
  1017.       mlo->lastNode = NULL;
  1018.    }
  1019.  
  1020.    /*
  1021.     * Okay, we have a window.  Now we need gadgets.
  1022.     */
  1023.    {
  1024.       struct TagItem tag[3];
  1025.       struct NewGadget ng;
  1026.  
  1027.       ng.ng_LeftEdge = 50;
  1028.       ng.ng_TopEdge = 45;
  1029.       ng.ng_Width = 300;
  1030.       ng.ng_Height = 90;
  1031.       ng.ng_Flags = PLACETEXT_ABOVE;
  1032.       tag[0].ti_Tag = GTLV_Labels;
  1033.       tag[0].ti_Data = (ULONG)&mlo->list;
  1034.  
  1035.       if (!meta || meta->meta_class == meta)
  1036.          tag[1].ti_Tag = GTLV_ShowSelected;
  1037.       else
  1038.          tag[1].ti_Tag = 0;
  1039.  
  1040.       tag[1].ti_Data = NULL;
  1041.       tag[2].ti_Tag = TAG_END;
  1042.       mlo->listObject = CreateInstance(NULL,
  1043.                                        GADGTCLASS,
  1044.                                        METACLASS,
  1045.                                        object,
  1046.                                        (meta)?((meta->meta_class == meta)?
  1047.                                                              "Class List:":
  1048.                                                              "Instances:")
  1049.                                              :"Meta List:",
  1050.                                        (!meta || meta->meta_class == meta)?
  1051.                                           object:NULL,
  1052.                                        METHOD_GADGET_SELECT,
  1053.                                        &ng,
  1054.                                        LISTVIEW_KIND,
  1055.                                        tag,
  1056.                                        METHOD_END);
  1057.  
  1058.       if (meta && (meta->meta_class != meta))
  1059.          return object;
  1060.  
  1061.       ng.ng_TopEdge += ng.ng_Height;
  1062.       ng.ng_Height = 15;
  1063.       ng.ng_Width = 80;
  1064.       ng.ng_Flags = PLACETEXT_RIGHT;
  1065.       tag[0].ti_Tag = TAG_END;
  1066.       mlo->object1 = CreateInstance(NULL,
  1067.                                     GADGTCLASS,
  1068.                                     METACLASS,
  1069.                                     object,
  1070.                                     ":Instance size",
  1071.                                     object,
  1072.                                     METHOD_GADGET_SELECT,
  1073.                                     &ng,
  1074.                                     NUMBER_KIND,
  1075.                                     tag,
  1076.                                     METHOD_END);
  1077.  
  1078.       ng.ng_TopEdge += ng.ng_Height;
  1079.       ng.ng_Height = 15;
  1080.       ng.ng_Width = 80;
  1081.       ng.ng_Flags = PLACETEXT_RIGHT;
  1082.       tag[0].ti_Tag = TAG_END;
  1083.       mlo->object2 = CreateInstance(NULL,
  1084.                                     GADGTCLASS,
  1085.                                     METACLASS,
  1086.                                     object,
  1087.                                     ":methodTable size",
  1088.                                     object,
  1089.                                     METHOD_GADGET_SELECT,
  1090.                                     &ng,
  1091.                                     NUMBER_KIND,
  1092.                                     tag,
  1093.                                     METHOD_END);
  1094.  
  1095.       ng.ng_TopEdge += ng.ng_Height;
  1096.       ng.ng_Height = 15;
  1097.       ng.ng_Width = 80;
  1098.       ng.ng_Flags = PLACETEXT_RIGHT;
  1099.       tag[0].ti_Tag = TAG_END;
  1100.       mlo->object3 = CreateInstance(NULL,
  1101.                                     GADGTCLASS,
  1102.                                     METACLASS,
  1103.                                     object,
  1104.                                     ":attributeTable size",
  1105.                                     object,
  1106.                                     METHOD_GADGET_SELECT,
  1107.                                     &ng,
  1108.                                     NUMBER_KIND,
  1109.                                     tag,
  1110.                                     METHOD_END);
  1111.  
  1112.       ng.ng_TopEdge += ng.ng_Height;
  1113.       ng.ng_Height = 15;
  1114.       ng.ng_Width = 80;
  1115.       ng.ng_Flags = PLACETEXT_RIGHT;
  1116.       tag[0].ti_Tag = TAG_END;
  1117.       mlo->object4 = CreateInstance(NULL,
  1118.                                     GADGTCLASS,
  1119.                                     METACLASS,
  1120.                                     object,
  1121.                                     NULL,
  1122.                                     object,
  1123.                                     METHOD_GADGET_SELECT,
  1124.                                     &ng,
  1125.                                     TEXT_KIND,
  1126.                                     tag,
  1127.                                     METHOD_END);
  1128.  
  1129.       ng.ng_TopEdge = 45;
  1130.       ng.ng_LeftEdge = 370;
  1131.       ng.ng_Height = 20;
  1132.       ng.ng_Width = 100;
  1133.       ng.ng_Flags = 0;
  1134.       tag[0].ti_Tag = TAG_END;
  1135.       DropObject(CreateInstance(NULL,
  1136.                                 GADGTCLASS,
  1137.                                 METACLASS,
  1138.                                 object,
  1139.                                 "Methods",
  1140.                                 object,
  1141.                                 METHOD_GADGET_OPEN_MWIN,
  1142.                                 &ng,
  1143.                                 BUTTON_KIND,
  1144.                                 tag,
  1145.                                 METHOD_END));
  1146.  
  1147.       ng.ng_TopEdge += ng.ng_Height;
  1148.       ng.ng_Height = 20;
  1149.       ng.ng_Width = 100;
  1150.       ng.ng_Flags = 0;
  1151.       tag[0].ti_Tag = TAG_END;
  1152.       DropObject(CreateInstance(NULL,
  1153.                                 GADGTCLASS,
  1154.                                 METACLASS,
  1155.                                 object,
  1156.                                 "Attributes",
  1157.                                 object,
  1158.                                 METHOD_GADGET_OPEN_AWIN,
  1159.                                 &ng,
  1160.                                 BUTTON_KIND,
  1161.                                 tag,
  1162.                                 METHOD_END));
  1163.  
  1164.       ng.ng_TopEdge += ng.ng_Height;
  1165.       ng.ng_Height = 20;
  1166.       ng.ng_Width = 100;
  1167.       ng.ng_Flags = 0;
  1168.       tag[0].ti_Tag = TAG_END;
  1169.       DropObject(CreateInstance(NULL,
  1170.                                 GADGTCLASS,
  1171.                                 METACLASS,
  1172.                                 object,
  1173.                                 "Instances",
  1174.                                 object,
  1175.                                 METHOD_GADGET_OPEN_OWIN,
  1176.                                 &ng,
  1177.                                 BUTTON_KIND,
  1178.                                 tag,
  1179.                                 METHOD_END));
  1180.    }
  1181.    return object;
  1182. }
  1183.  
  1184. void CWinNotifyMethod(METHOD_ARGS, long flags,
  1185.                                        W_VALUE watcher,
  1186.                                        void *first,
  1187.                                        void *second)
  1188. {
  1189.    struct CWinLocalObjects *mlo;
  1190.    struct TagItem tags[2];
  1191.    struct MyNode *node;
  1192.  
  1193.    mlo = FindAttribute(object, ATTR_LOCALWIN);
  1194.    if (!mlo->director)
  1195.       return;
  1196.  
  1197.    tags[0].ti_Tag = GTLV_Labels;
  1198.    tags[0].ti_Data = ~0;
  1199.    tags[1].ti_Tag = TAG_END;
  1200.    DoJazzMethod(mlo->listObject, NULL, METHOD_GADGET_CHANGE,
  1201.                                           tags,
  1202.                                           METHOD_END);
  1203.    if (flags & W_INSERT)
  1204.    {
  1205.  
  1206.       if (!(node = AllocateItem(&mlo->myMemList)))
  1207.          return;
  1208.       if (second != first)
  1209.       {
  1210.          node->node.ln_Name = UseString((char *)second);
  1211.       } else
  1212.       {
  1213.          char buffer[20];
  1214.  
  1215.          RawDoFmt("Object at: %lx", &first, SprintfCallback, buffer);
  1216.  
  1217.          node->node.ln_Name = UseString(buffer);
  1218.       }
  1219.  
  1220.       node->object = first;
  1221.       UseObject(first);
  1222.       AddTail(&mlo->list, node);
  1223.    } else if (flags & W_REMOVE)
  1224.    {
  1225.       char *name;
  1226.  
  1227.       if (second != first)
  1228.       {
  1229.          name = FindString((char *)second);
  1230.       } else
  1231.       {
  1232.          char buffer[20];
  1233.  
  1234.          RawDoFmt("Object at: %lx", &first, SprintfCallback, buffer);
  1235.          name = FindString(buffer);
  1236.       }
  1237.       for(node = (struct MyNode *)mlo->list.lh_Head;
  1238.           node->node.ln_Succ;
  1239.           node = (struct MyNode *)node->node.ln_Succ)
  1240.       {
  1241.          if (node->node.ln_Name == name && node->object == first)
  1242.          {
  1243.             QuickDropString(name);
  1244.             DropObject(first);
  1245.             Remove(node);
  1246.             FreeItem(&mlo->myMemList, node);
  1247.             if (mlo->lastNode == node)
  1248.                mlo->lastNode = NULL;
  1249.             break;
  1250.          }
  1251.       }
  1252.    }
  1253.    tags[0].ti_Tag = GTLV_Labels;
  1254.    tags[0].ti_Data = (ULONG)&mlo->list;
  1255.    DoJazzMethod(mlo->listObject, NULL, METHOD_GADGET_CHANGE,
  1256.                                           tags,
  1257.                                           METHOD_END);
  1258. }
  1259.  
  1260. void CWinRemoveMethod(METHOD_ARGS)
  1261. {
  1262.    struct CWinLocalObjects *mlo;
  1263.    struct Node *node;
  1264.  
  1265.  
  1266.    mlo = FindAttribute(object, ATTR_LOCALWIN);
  1267.    RemoveObject(SetObject(&mlo->director, NULL));
  1268.  
  1269.    node = mlo->list.lh_Head;
  1270.  
  1271.    UseObject(object);         /* Make sure object stays around! */
  1272.    CallSuper();               /* Let GadTools know to get rid of gadgets. */
  1273.  
  1274.    NewList(&mlo->list);
  1275.    for(; node->ln_Succ; node = node->ln_Succ)
  1276.    {
  1277.       DropObject(((struct MyNode *)node)->object);
  1278.       QuickDropString(node->ln_Name);
  1279.    }
  1280.    DropObject(object);        /* OKAY, now we're done! */
  1281. }
  1282.  
  1283. void CWinDestroyMethod(METHOD_ARGS)
  1284. {
  1285.    struct CWinLocalObjects *mlo;
  1286.  
  1287.    mlo = FindAttribute(object, ATTR_LOCALWIN);
  1288.    DropObject(mlo->object1);
  1289.    DropObject(mlo->object2);
  1290.    DropObject(mlo->object3);
  1291.    DropObject(mlo->object4);
  1292.    DropObject(mlo->listObject);
  1293.    DropObject(mlo->meta);
  1294.    QuickDropString(mlo->superClassText);
  1295.  
  1296.    FreeTable(&mlo->myMemList);
  1297.    CallSuper();
  1298. }
  1299.  
  1300.  
  1301. /*
  1302.  * Selected a new item in the list.
  1303.  * So update all of our information.
  1304.  * Only called if this is a class information window -- not for an
  1305.  *  instances window.
  1306.  */
  1307. METHOD_REF REF_CWinHitMethod[] = {
  1308.                                     'long', sizeof(long), 0,
  1309.                                     TAG_DONE
  1310.                                  };
  1311.  
  1312. void CWinHitMethod(METHOD_ARGS, long code)
  1313. {
  1314.    struct CWinLocalObjects *mlo;
  1315.    META   meta;
  1316.    struct TagItem tags[2];
  1317.  
  1318.    mlo = FindAttribute(object, ATTR_LOCALWIN);
  1319.  
  1320.    {
  1321.       struct Node *node;
  1322.  
  1323.       for(node = mlo->list.lh_Head; code; --code)
  1324.          node = node->ln_Succ;
  1325.       mlo->lastNode = (struct MyNode *)node;
  1326.    }
  1327.  
  1328.    /*
  1329.     * Instance size gadget.
  1330.     */
  1331.    tags[0].ti_Tag = GTNM_Number;
  1332.    tags[0].ti_Data = ((META)(mlo->lastNode->object))->meta_size;
  1333.    tags[1].ti_Tag = TAG_END;
  1334.    DoJazzMethod(mlo->object1, NULL, METHOD_GADGET_CHANGE, tags, METHOD_END);
  1335.  
  1336.    /*
  1337.     * Method table size in bytes.
  1338.     */
  1339.    tags[0].ti_Data = ((META)
  1340.                       (mlo->lastNode->object))->meta_verbs.mt_num *
  1341.                      sizeof(struct MethodHandler);
  1342.    DoJazzMethod(mlo->object2, NULL, METHOD_GADGET_CHANGE, tags, METHOD_END);
  1343.  
  1344.    /*
  1345.     * Attribute table size in bytes.
  1346.     */
  1347.    tags[0].ti_Data = ((META)
  1348.                       (mlo->lastNode->object))->meta_attributes.att_num *
  1349.                      sizeof(struct Attribute);
  1350.    DoJazzMethod(mlo->object3, NULL, METHOD_GADGET_CHANGE, tags, METHOD_END);
  1351.  
  1352.    /*
  1353.     * superClass name.
  1354.     */
  1355.    tags[0].ti_Tag = GTTX_Text;
  1356.    meta = ((META)(mlo->lastNode->object))->meta_superClass;
  1357.    if (meta)
  1358.    {
  1359.       QuickDropString(mlo->superClassText);
  1360.  
  1361.       tags[0].ti_Data = (ULONG)(mlo->superClassText =
  1362.                         UseString(meta->meta_name));
  1363.    }
  1364.    else
  1365.       tags[0].ti_Data = 0L;
  1366.    DoJazzMethod(mlo->object4, NULL, METHOD_GADGET_CHANGE, tags, METHOD_END);
  1367. }
  1368.  
  1369. void CWinOpenMWinMethod(METHOD_ARGS)
  1370. {
  1371.    struct CWinLocalObjects *mlo;
  1372.    struct GUIStruct *gui;
  1373.  
  1374.    mlo = FindAttribute(object, ATTR_LOCALWIN);
  1375.    gui = FindAttribute(object, ATTR_GUISTRUCT);
  1376.  
  1377.    if (!mlo->lastNode)
  1378.       return;
  1379.  
  1380.    DropObject(CreateInstance(NULL,
  1381.                              METWINCLASS,
  1382.                              METACLASS,
  1383.                              gui->gui_parent,
  1384.                              mlo->lastNode->object,
  1385.                              METHOD_END));
  1386. }
  1387.  
  1388. void CWinOpenAWinMethod(METHOD_ARGS)
  1389. {
  1390.    struct CWinLocalObjects *mlo;
  1391.    struct GUIStruct *gui;
  1392.  
  1393.    mlo = FindAttribute(object, ATTR_LOCALWIN);
  1394.    gui = FindAttribute(object, ATTR_GUISTRUCT);
  1395.  
  1396.    if (!mlo->lastNode)
  1397.       return;
  1398.  
  1399.    DropObject(CreateInstance(NULL,
  1400.                              ATTWINCLASS,
  1401.                              METACLASS,
  1402.                              gui->gui_parent,
  1403.                              mlo->lastNode->object,
  1404.                              METHOD_END));
  1405. }
  1406.  
  1407. void CWinOpenOWinMethod(METHOD_ARGS)
  1408. {
  1409.    struct CWinLocalObjects *mlo;
  1410.    struct GUIStruct *gui;
  1411.  
  1412.    mlo = FindAttribute(object, ATTR_LOCALWIN);
  1413.    gui = FindAttribute(object, ATTR_GUISTRUCT);
  1414.  
  1415.    if (!mlo->lastNode)
  1416.       return;
  1417.  
  1418.    DropObject(CreateInstance(NULL,
  1419.                              CWINCLASS,
  1420.                              METACLASS,
  1421.                              gui->gui_parent,
  1422.                              mlo->lastNode->object,
  1423.                              METHOD_END));
  1424. }
  1425.  
  1426. /*
  1427.  * MetWin Class methods.
  1428.  */
  1429. METHOD_REF REF_MetWinInitMethod[] = {
  1430.                                        {'JOBJ', sizeof(void *),
  1431.                                                 SHADOW_OBJECT},
  1432.                                        {'JOBJ', sizeof(void *),
  1433.                                                 SHADOW_CLASS},
  1434.                                        {TAG_END, SHADOW_RETURN_OBJECT, 0}
  1435.                                     };
  1436. void *MetWinInitMethod(METHOD_ARGS, OBJECT parent,
  1437.                                     CLASS theClass)
  1438. {
  1439.    struct NewGadget ng;
  1440.    struct TagItem tag[8];
  1441.    struct MWinLocalObjects *mlo;
  1442.    char buffer[128];
  1443.  
  1444.    tag[0].ti_Tag = WA_Width;
  1445.    tag[0].ti_Data = 500;
  1446.    tag[1].ti_Tag = WA_Height;
  1447.    tag[1].ti_Data = 200;
  1448.    tag[2].ti_Tag = WA_MinWidth;
  1449.    tag[2].ti_Data = 60;
  1450.    tag[3].ti_Tag = WA_MinHeight;
  1451.    tag[3].ti_Data = 40;
  1452.    tag[4].ti_Tag = WA_MaxWidth;
  1453.    tag[4].ti_Data = -1;
  1454.    tag[5].ti_Tag = WA_MaxHeight;
  1455.    tag[5].ti_Data = -1;
  1456.    tag[6].ti_Tag = WA_SimpleRefresh;
  1457.    tag[6].ti_Data = TRUE;
  1458.    tag[7].ti_Tag = TAG_END;
  1459.  
  1460.    object = DoJazzMethod(object, class->meta_superClass, MethodID,
  1461.                                                  parent,
  1462.                                                  "Method Window",
  1463.                                                  NULL,
  1464.                                                  NULL,
  1465.                                                  tag, METHOD_END);
  1466.    if (!object)
  1467.       return NULL;
  1468.  
  1469.    mlo = FindAttribute(object, ATTR_LOCALWIN);
  1470.    mlo->class = UseObject(theClass);
  1471.    NewList(&mlo->list);
  1472.  
  1473.    if (theClass->ccl_verbs.mt_num)
  1474.    {
  1475.       struct MethodHandler *methods;
  1476.       struct MyNode *nodes;
  1477.       int i;
  1478.  
  1479.       mlo->nodes = AllocVec(sizeof(struct MyNode) * theClass->ccl_verbs.mt_num,
  1480.                             MEMF_PUBLIC);
  1481.  
  1482.       nodes = mlo->nodes;
  1483.       for (methods = theClass->ccl_verbs.mt_methods, i = 0;
  1484.            i < theClass->ccl_verbs.mt_num;
  1485.            i++, methods++)
  1486.       {
  1487.          nodes->node.ln_Name = UseString(methods->mh_methodID);
  1488.          nodes->object = methods;
  1489.          AddTail(&mlo->list, nodes);
  1490.          nodes++;
  1491.       }
  1492.  
  1493.    }
  1494.  
  1495.    ng.ng_LeftEdge = ng.ng_TopEdge = 50;
  1496.    ng.ng_Width = 300;
  1497.    ng.ng_Height = 90;
  1498.    ng.ng_Flags = PLACETEXT_ABOVE;
  1499.    tag[0].ti_Tag = GTLV_Labels;
  1500.    tag[0].ti_Data = (ULONG)&mlo->list;
  1501.    tag[1].ti_Tag = GTLV_ShowSelected;
  1502.    tag[1].ti_Data = NULL;
  1503.    tag[2].ti_Tag = TAG_END;
  1504.    strcpy(buffer, "Method list for class: ");
  1505.    strncat(buffer, theClass->ccl_name, 14);
  1506.    strcat(buffer, "...");
  1507.    DropObject(CreateInstance(NULL,
  1508.                              GADGTCLASS,
  1509.                              METACLASS,
  1510.                              object,
  1511.                              buffer,
  1512.                              object,
  1513.                              METHOD_GADGET_SELECT,
  1514.                              &ng,
  1515.                              LISTVIEW_KIND,
  1516.                              tag,
  1517.                              METHOD_END));
  1518.  
  1519.    ng.ng_TopEdge += ng.ng_Height;
  1520.    ng.ng_Height = 15;
  1521.    ng.ng_Width = 170;
  1522.    ng.ng_Flags = PLACETEXT_RIGHT;
  1523.    tag[0].ti_Tag = TAG_END;
  1524.    mlo->object1 = CreateInstance(NULL,
  1525.                                  GADGTCLASS,
  1526.                                  METACLASS,
  1527.                                  object,
  1528.                                  ":Controlled",
  1529.                                  object,
  1530.                                  METHOD_GADGET_SELECT,
  1531.                                  &ng,
  1532.                                  TEXT_KIND,
  1533.                                  tag,
  1534.                                  METHOD_END);
  1535.  
  1536.    ng.ng_TopEdge += ng.ng_Height;
  1537.    ng.ng_Height = 15;
  1538.    ng.ng_Width = 170;
  1539.    ng.ng_Flags = PLACETEXT_RIGHT;
  1540.    tag[0].ti_Tag = TAG_END;
  1541.    mlo->object2 = CreateInstance(NULL,
  1542.                                  GADGTCLASS,
  1543.                                  METACLASS,
  1544.                                  object,
  1545.                                  ":Defined",
  1546.                                  object,
  1547.                                  METHOD_GADGET_SELECT,
  1548.                                  &ng,
  1549.                                  TEXT_KIND,
  1550.                                  tag,
  1551.                                  METHOD_END);
  1552.  
  1553.    ng.ng_TopEdge += ng.ng_Height;
  1554.    ng.ng_Height = 15;
  1555.    ng.ng_Width = 170;
  1556.    ng.ng_Flags = PLACETEXT_RIGHT;
  1557.    tag[0].ti_Tag = TAG_END;
  1558.    mlo->object3 = CreateInstance(NULL,
  1559.                                  GADGTCLASS,
  1560.                                  METACLASS,
  1561.                                  object,
  1562.                                  ":Function address",
  1563.                                  object,
  1564.                                  METHOD_GADGET_SELECT,
  1565.                                  &ng,
  1566.                                  NUMBER_KIND,
  1567.                                  tag,
  1568.                                  METHOD_END);
  1569.  
  1570.    ng.ng_TopEdge += ng.ng_Height;
  1571.    ng.ng_Height = 15;
  1572.    ng.ng_Width = 170;
  1573.    ng.ng_Flags = PLACETEXT_RIGHT;
  1574.    tag[0].ti_Tag = TAG_END;
  1575.    mlo->object4 = CreateInstance(NULL,
  1576.                                  GADGTCLASS,
  1577.                                  METACLASS,
  1578.                                  object,
  1579.                                  ":threadStat",
  1580.                                  object,
  1581.                                  METHOD_GADGET_SELECT,
  1582.                                  &ng,
  1583.                                  TEXT_KIND,
  1584.                                  tag,
  1585.                                  METHOD_END);
  1586.  
  1587.    ng.ng_TopEdge = 50;
  1588.    ng.ng_LeftEdge = 370;
  1589.    ng.ng_Height = 20;
  1590.    ng.ng_Width = 100;
  1591.    ng.ng_Flags = 0;
  1592.    tag[0].ti_Tag = TAG_END;
  1593.    DropObject(CreateInstance(NULL,
  1594.                              GADGTCLASS,
  1595.                              METACLASS,
  1596.                              object,
  1597.                              "Arguments",
  1598.                              object,
  1599.                              METHOD_GADGET_OPEN_RWIN,
  1600.                              &ng,
  1601.                              BUTTON_KIND,
  1602.                              tag,
  1603.                              METHOD_END));
  1604.  
  1605.    ng.ng_TopEdge += ng.ng_Height;
  1606.    ng.ng_Height = 15;
  1607.    ng.ng_Width = 25;
  1608.    ng.ng_Flags = PLACETEXT_RIGHT;
  1609.    tag[0].ti_Tag = TAG_END;
  1610.    mlo->object5 = CreateInstance(NULL,
  1611.                                  GADGTCLASS,
  1612.                                  METACLASS,
  1613.                                  object,
  1614.                                  ":Patches",
  1615.                                  object,
  1616.                                  METHOD_GADGET_SELECT,
  1617.                                  &ng,
  1618.                                  NUMBER_KIND,
  1619.                                  tag,
  1620.                                  METHOD_END);
  1621.  
  1622.    /*
  1623.     * So watch the Patch list....
  1624.     */
  1625.    {
  1626.       mlo->director = CreateInstance(NULL,
  1627.                                      DIRECTORCLASS,
  1628.                                      METACLASS,
  1629.                                      "Watch Patches",
  1630.                                      object,
  1631.                                      METHOD_METHOD_UPDATE_INFO,
  1632.                                        (W_INSERT_NODE | W_REMOVE) |
  1633.                                        (SHADOW_OBJECT << 16) |
  1634.                                        W_FLAG_AUTOBREAK |
  1635.                                        W_FLAG_AUTOREMOVE,
  1636.                                      METHOD_END);
  1637.       DropObject( DoJazzMethod(mlo->director,
  1638.                                NULL,
  1639.                                METHOD_DIRECTOR_ESTABLISH,
  1640.                                ATTR_PATCHEDVERBS,
  1641.                                theClass,
  1642.                                METHOD_END));
  1643.    }
  1644.    return object;
  1645. }
  1646.  
  1647. void MetWinDestroyMethod(METHOD_ARGS)
  1648. {
  1649.    struct MWinLocalObjects *mlo;
  1650.    struct Node *node;
  1651.  
  1652.    mlo = FindAttribute(object, ATTR_LOCALWIN);
  1653.    DropObject(mlo->object1);
  1654.    DropObject(mlo->object2);
  1655.    DropObject(mlo->object3);
  1656.    DropObject(mlo->object4);
  1657.    DropObject(mlo->object5);
  1658.    DropObject(mlo->class);
  1659.  
  1660.    if (mlo->nodes)
  1661.    {
  1662.       for(node = mlo->list.lh_Head; node->ln_Succ; node = node->ln_Succ)
  1663.          QuickDropString(node->ln_Name);
  1664.  
  1665.       FreeVec(mlo->nodes);
  1666.    }
  1667.  
  1668.    CallSuper();
  1669. }
  1670.  
  1671. void MetWinRemoveMethod(METHOD_ARGS)
  1672. {
  1673.    struct MWinLocalObjects *mlo;
  1674.  
  1675.    mlo = FindAttribute(object, ATTR_LOCALWIN);
  1676.    RemoveObject(SetObject(&mlo->director, NULL));
  1677.    mlo->director = NULL;
  1678.  
  1679.    CallSuper();
  1680. }
  1681.  
  1682. void MetWinUpdateInfo(METHOD_ARGS)
  1683. {
  1684.    struct MWinLocalObjects *mlo;
  1685.    struct TagItem tags[2];
  1686.  
  1687.    mlo = FindAttribute(object, ATTR_LOCALWIN);
  1688.  
  1689.    tags[0].ti_Tag = GTNM_Number;
  1690.    tags[1].ti_Tag = TAG_END;
  1691.  
  1692.    /*
  1693.     * Number of Patches
  1694.     */
  1695.    tags[0].ti_Data = (ULONG)((struct MethodHandler *)
  1696.                       (mlo->lastNode->object))->mh_numPatches;
  1697.    DoJazzMethod(mlo->object5, NULL, METHOD_GADGET_CHANGE, tags, METHOD_END);
  1698.  
  1699. }
  1700.  
  1701. /*
  1702.  * Selected a new method, so update all the method information.
  1703.  */
  1704. METHOD_REF REF_MetWinHitMethod[] = {
  1705.                                       'long', sizeof(long), 0,
  1706.                                       TAG_DONE
  1707.                                    };
  1708.  
  1709. void MetWinHitMethod(METHOD_ARGS, long code)
  1710. {
  1711.    struct MWinLocalObjects *mlo;
  1712.    struct TagItem tags[2];
  1713.  
  1714.    mlo = FindAttribute(object, ATTR_LOCALWIN);
  1715.  
  1716.    mlo->lastNode = &mlo->nodes[code];
  1717.  
  1718.    tags[0].ti_Tag = GTTX_Text;
  1719.    tags[1].ti_Tag = TAG_END;
  1720.  
  1721.    /*
  1722.     * Controlled Process Object.
  1723.     */
  1724.    {
  1725.       OBJECT object;
  1726.       struct JazzProcess *jp;
  1727.  
  1728.       object = ((struct MethodHandler *)
  1729.                 (mlo->lastNode->object))->mh_procObject;
  1730.       if (!( ((struct MethodHandler *)mlo->lastNode->object)->mh_flags &
  1731.             METHOD_FLAG_PORT) &&
  1732.           (jp = FindAttribute(object, ATTR_JAZZPROCESS)))
  1733.          tags[0].ti_Data = (ULONG)jp->jp_procName;
  1734.       else
  1735.          tags[0].ti_Data = 0;
  1736.    }
  1737.    DoJazzMethod(mlo->object1, NULL, METHOD_GADGET_CHANGE, tags, METHOD_END);
  1738.  
  1739.    /*
  1740.     * Defined Process Object.
  1741.     */
  1742.    {
  1743.       OBJECT object;
  1744.       struct JazzProcess *jp;
  1745.  
  1746.       object = ((struct MethodHandler *)
  1747.                 (mlo->lastNode->object))->mh_defnObject;
  1748.       if (jp = FindAttribute(object, ATTR_JAZZPROCESS))
  1749.          tags[0].ti_Data = (ULONG)jp->jp_procName;
  1750.       else
  1751.          tags[0].ti_Data = 0;
  1752.    }
  1753.    DoJazzMethod(mlo->object2, NULL, METHOD_GADGET_CHANGE, tags, METHOD_END);
  1754.  
  1755.    /*
  1756.     * Function Address
  1757.     */
  1758.    tags[0].ti_Tag = GTNM_Number;
  1759.    tags[0].ti_Data = (ULONG)((struct MethodHandler *)
  1760.                       (mlo->lastNode->object))->mh_method;
  1761.    DoJazzMethod(mlo->object3, NULL, METHOD_GADGET_CHANGE, tags, METHOD_END);
  1762.  
  1763.    /*
  1764.     * Number of Patches
  1765.     */
  1766.    tags[0].ti_Tag = GTNM_Number;
  1767.    tags[0].ti_Data = (ULONG)((struct MethodHandler *)
  1768.                       (mlo->lastNode->object))->mh_numPatches;
  1769.    DoJazzMethod(mlo->object5, NULL, METHOD_GADGET_CHANGE, tags, METHOD_END);
  1770.  
  1771.    /*
  1772.     * ThreadStat
  1773.     */
  1774.    tags[0].ti_Tag = GTTX_Text;
  1775.    switch(((struct MethodHandler *)
  1776.           (mlo->lastNode->object))->mh_threadStat &
  1777.           (SHADOW_MSG_FORCE | SHADOW_MSG_SYNC | SHADOW_MSG_ASYNC))
  1778.    {
  1779.        case SHADOW_MSG_CALL:
  1780.           tags[0].ti_Data = (ULONG)"Function call";
  1781.           break;
  1782.        case SHADOW_MSG_SYNC:
  1783.           tags[0].ti_Data = (ULONG)"Synchronous call";
  1784.           break;
  1785.        case SHADOW_MSG_ASYNC:
  1786.           tags[0].ti_Data = (ULONG)"Asynchronous call";
  1787.           break;
  1788.        case SHADOW_MSG_FORCE_SYNC:
  1789.           tags[0].ti_Data = (ULONG)"forced synch. call";
  1790.           break;
  1791.        default:
  1792.           tags[0].ti_Data = (ULONG)"forced async. call";
  1793.           break;
  1794.    }
  1795.    DoJazzMethod(mlo->object4, NULL, METHOD_GADGET_CHANGE, tags, METHOD_END);
  1796. }
  1797.  
  1798. /*
  1799.  * Open the Reference (parameter) Window.
  1800.  */
  1801. void MWinOpenRWinMethod(METHOD_ARGS)
  1802. {
  1803.    struct MWinLocalObjects *mlo;
  1804.  
  1805.    mlo = FindAttribute(object, ATTR_LOCALWIN);
  1806.  
  1807.    if (!mlo->lastNode)
  1808.       return;
  1809.  
  1810.    DropObject(CreateInstance(NULL,
  1811.                              REFWINCLASS,
  1812.                              METACLASS,
  1813.                              object,
  1814.                              mlo->lastNode->object,
  1815.                              mlo->class,
  1816.                              METHOD_END));
  1817. }
  1818.  
  1819.  
  1820. /*
  1821.  * AttWin Class methods.
  1822.  */
  1823. METHOD_REF REF_AttWinInitMethod[] = {
  1824.                                        {'JOBJ', sizeof(void *),
  1825.                                                 SHADOW_OBJECT},
  1826.                                        {'JOBJ', sizeof(void *),
  1827.                                                 SHADOW_CLASS},
  1828.                                        { TAG_END, SHADOW_RETURN_OBJECT, 0}
  1829.                                     };
  1830. void *AttWinInitMethod(METHOD_ARGS, OBJECT parent,
  1831.                                     CLASS  theClass)
  1832. {
  1833.    struct NewGadget ng;
  1834.    struct TagItem tag[8];
  1835.    struct AWinLocalObjects *mlo;
  1836.    char buffer[128];
  1837.  
  1838.    tag[0].ti_Tag = WA_Width;
  1839.    tag[0].ti_Data = 500;
  1840.    tag[1].ti_Tag = WA_Height;
  1841.    tag[1].ti_Data = 200;
  1842.    tag[2].ti_Tag = WA_MinWidth;
  1843.    tag[2].ti_Data = 60;
  1844.    tag[3].ti_Tag = WA_MinHeight;
  1845.    tag[3].ti_Data = 40;
  1846.    tag[4].ti_Tag = WA_MaxWidth;
  1847.    tag[4].ti_Data = -1;
  1848.    tag[5].ti_Tag = WA_MaxHeight;
  1849.    tag[5].ti_Data = -1;
  1850.    tag[6].ti_Tag = WA_SimpleRefresh;
  1851.    tag[6].ti_Data = TRUE;
  1852.    tag[7].ti_Tag = TAG_END;
  1853.  
  1854.    object = DoJazzMethod(object, class->meta_superClass, MethodID,
  1855.                                                  parent,
  1856.                                                  "Attribute Window",
  1857.                                                  NULL,
  1858.                                                  NULL,
  1859.                                                  tag, METHOD_END);
  1860.  
  1861.    if (!object)
  1862.       return NULL;
  1863.  
  1864.    mlo = FindAttribute(object, ATTR_LOCALWIN);
  1865.    mlo->meta = UseObject(theClass);
  1866.    NewList(&mlo->list);
  1867.  
  1868.    /*
  1869.     * Copy all of the attributes into the allocated list.
  1870.     */
  1871.    if (theClass->ccl_attributes.att_num)
  1872.    {
  1873.       struct Attribute *attrs;
  1874.       struct MyNode *nodes;
  1875.       int i;
  1876.  
  1877.       mlo->nodes = AllocVec(sizeof(struct MyNode) *
  1878.                                  theClass->ccl_attributes.att_num,
  1879.                             MEMF_PUBLIC);
  1880.  
  1881.       nodes = mlo->nodes;
  1882.       for (attrs = theClass->ccl_attributes.att_attrs, i = 0;
  1883.            i < theClass->ccl_attributes.att_num;
  1884.            i++, attrs++)
  1885.       {
  1886.          nodes->node.ln_Name = UseString(attrs->attr_name);
  1887.          nodes->object = attrs;
  1888.          AddTail(&mlo->list, nodes);
  1889.          nodes++;
  1890.       }
  1891.    }
  1892.  
  1893.    ng.ng_LeftEdge = ng.ng_TopEdge = 50;
  1894.    ng.ng_Width = 300;
  1895.    ng.ng_Height = 90;
  1896.    ng.ng_Flags = PLACETEXT_ABOVE;
  1897.    tag[0].ti_Tag = GTLV_Labels;
  1898.    tag[0].ti_Data = (ULONG)&mlo->list;
  1899.    tag[1].ti_Tag = GTLV_ShowSelected;
  1900.    tag[1].ti_Data = NULL;
  1901.    tag[2].ti_Tag = TAG_END;
  1902.    strcpy(buffer, "Attributes for class: ");
  1903.    strncat(buffer, theClass->ccl_name, 14);
  1904.    strcat(buffer, "...");
  1905.    DropObject(CreateInstance(NULL,
  1906.                              GADGTCLASS,
  1907.                              METACLASS,
  1908.                              object,
  1909.                              buffer,
  1910.                              object,
  1911.                              METHOD_GADGET_SELECT,
  1912.                              &ng,
  1913.                              LISTVIEW_KIND,
  1914.                              tag,
  1915.                              METHOD_END));
  1916.  
  1917.    ng.ng_TopEdge += ng.ng_Height;
  1918.    ng.ng_Height = 15;
  1919.    ng.ng_Width = 80;
  1920.    ng.ng_Flags = PLACETEXT_RIGHT;
  1921.    tag[0].ti_Tag = TAG_END;
  1922.    mlo->object1 = CreateInstance(NULL,
  1923.                                  GADGTCLASS,
  1924.                                  METACLASS,
  1925.                                  object,
  1926.                                  ":Attribute offset",
  1927.                                  object,
  1928.                                  METHOD_GADGET_SELECT,
  1929.                                  &ng,
  1930.                                  NUMBER_KIND,
  1931.                                  tag,
  1932.                                  METHOD_END);
  1933.  
  1934.    ng.ng_TopEdge += ng.ng_Height;
  1935.    ng.ng_Height = 15;
  1936.    ng.ng_Width = 80;
  1937.    ng.ng_Flags = PLACETEXT_RIGHT;
  1938.    tag[0].ti_Tag = TAG_END;
  1939.    mlo->object2 = CreateInstance(NULL,
  1940.                                  GADGTCLASS,
  1941.                                  METACLASS,
  1942.                                  object,
  1943.                                  ":size",
  1944.                                  object,
  1945.                                  METHOD_GADGET_SELECT,
  1946.                                  &ng,
  1947.                                  NUMBER_KIND,
  1948.                                  tag,
  1949.                                  METHOD_END);
  1950.  
  1951.    ng.ng_TopEdge += ng.ng_Height;
  1952.    ng.ng_Height = 15;
  1953.    ng.ng_Width = 80;
  1954.    ng.ng_Flags = PLACETEXT_RIGHT;
  1955.    tag[0].ti_Tag = TAG_END;
  1956.    mlo->object3 = CreateInstance(NULL,
  1957.                                  GADGTCLASS,
  1958.                                  METACLASS,
  1959.                                  object,
  1960.                                  ":watcher list",
  1961.                                  object,
  1962.                                  METHOD_GADGET_SELECT,
  1963.                                  &ng,
  1964.                                  NUMBER_KIND,
  1965.                                  tag,
  1966.                                  METHOD_END);
  1967.  
  1968.    ng.ng_TopEdge += ng.ng_Height;
  1969.    ng.ng_Height = 15;
  1970.    ng.ng_Width = 80;
  1971.    ng.ng_Flags = PLACETEXT_RIGHT;
  1972.    tag[0].ti_Tag = TAG_END;
  1973.    mlo->object4 = CreateInstance(NULL,
  1974.                                  GADGTCLASS,
  1975.                                  METACLASS,
  1976.                                  object,
  1977.                                  ":default object",
  1978.                                  object,
  1979.                                  METHOD_GADGET_SELECT,
  1980.                                  &ng,
  1981.                                  NUMBER_KIND,
  1982.                                  tag,
  1983.                                  METHOD_END);
  1984.    return object;
  1985. }
  1986.  
  1987. void AttWinDestroyMethod(METHOD_ARGS)
  1988. {
  1989.    struct AWinLocalObjects *mlo;
  1990.    struct Node *node;
  1991.  
  1992.    mlo = FindAttribute(object, ATTR_LOCALWIN);
  1993.    DropObject(mlo->object1);
  1994.    DropObject(mlo->object2);
  1995.    DropObject(mlo->object3);
  1996.    DropObject(mlo->object4);
  1997.    DropObject(mlo->meta);
  1998.  
  1999.    if (mlo->nodes)
  2000.    {
  2001.       for(node = mlo->list.lh_Head; node->ln_Succ; node = node->ln_Succ)
  2002.          QuickDropString(node->ln_Name);
  2003.  
  2004.       FreeVec(mlo->nodes);
  2005.    }
  2006.  
  2007.    CallSuper();
  2008. }
  2009.  
  2010. /*
  2011.  * New Attribute selected, display its information.
  2012.  */
  2013. METHOD_REF  REF_AttWinHitMethod[] = {
  2014.                                        'long', sizeof(long), 0,
  2015.                                        TAG_DONE
  2016.                                     };
  2017.  
  2018. void AttWinHitMethod(METHOD_ARGS, long code)
  2019. {
  2020.    struct AWinLocalObjects *mlo;
  2021.    struct TagItem tags[2];
  2022.  
  2023.    mlo = FindAttribute(object, ATTR_LOCALWIN);
  2024.  
  2025.    mlo->lastNode = &mlo->nodes[code];
  2026.  
  2027.    tags[0].ti_Tag = GTNM_Number;
  2028.    tags[0].ti_Data = ((struct Attribute *)
  2029.                       (mlo->lastNode->object))->attr_offset;
  2030.    tags[1].ti_Tag = TAG_END;
  2031.  
  2032.    /*
  2033.     * Offset.
  2034.     */
  2035.    DoJazzMethod(mlo->object1, NULL, METHOD_GADGET_CHANGE, tags, METHOD_END);
  2036.  
  2037.    /*
  2038.     * Size
  2039.     */
  2040.    tags[0].ti_Data = ((struct Attribute *)
  2041.                       (mlo->lastNode->object))->attr_size;
  2042.    if (tags[0].ti_Data & FLAG_ATTR_WATCHED)
  2043.       tags[0].ti_Data = sizeof(struct WatchedBinTree);
  2044.    DoJazzMethod(mlo->object2, NULL, METHOD_GADGET_CHANGE, tags, METHOD_END);
  2045.  
  2046.    /*
  2047.     * if watched (attr->size & FLAG_ATTR_WATCHED), then display it.
  2048.     *  else -1.
  2049.     */
  2050.    if (FLAG_ATTR_WATCHED & ((struct Attribute *)
  2051.                             (mlo->lastNode->object))->attr_size)
  2052.       tags[0].ti_Data = (ULONG)((struct Attribute *)
  2053.                       (mlo->lastNode->object))->attr_first;
  2054.    else
  2055.       tags[0].ti_Data = -1;
  2056.    DoJazzMethod(mlo->object3, NULL, METHOD_GADGET_CHANGE, tags, METHOD_END);
  2057.  
  2058.    /*
  2059.     * default Object.
  2060.     */
  2061.    if (FLAG_ATTR_WATCHED & ((struct Attribute *)
  2062.                             (mlo->lastNode->object))->attr_size)
  2063.       tags[0].ti_Data = (~FLAG_ATTR_WATCHED & ((struct Attribute *)
  2064.                           (mlo->lastNode->object))->attr_size);
  2065.    else
  2066.       tags[0].ti_Data = (ULONG)((struct Attribute *)
  2067.                          (mlo->lastNode->object))->attr_value;
  2068.    DoJazzMethod(mlo->object4, NULL, METHOD_GADGET_CHANGE, tags, METHOD_END);
  2069. }
  2070.  
  2071.  
  2072. /*
  2073.  * RefWin Class methods.
  2074.  */
  2075. METHOD_REF REF_RefWinInitMethod[] = {
  2076.                                        {'JOBJ', sizeof(void *),
  2077.                                                 SHADOW_OBJECT},
  2078.                                        {'MREF', sizeof(void *),
  2079.                                                 sizeof(struct MethodHandler)},
  2080.                                        {'JOBJ', sizeof(void *),
  2081.                                                 SHADOW_CLASS},
  2082.                                        {TAG_END, SHADOW_RETURN_OBJECT, 0}
  2083.                                     };
  2084. void *RefWinInitMethod(METHOD_ARGS, OBJECT parent,
  2085.                                     struct MethodHandler *method,
  2086.                                     CLASS mclass)
  2087. {
  2088.    char *name;
  2089.    char buffer[256];
  2090.    struct TagItem tag[8];
  2091.    struct NewGadget ng;
  2092.    struct RWinLocalObjects *mlo;
  2093.  
  2094.    strcpy(buffer, "Arguments to: ");
  2095.    strncat(buffer, method->mh_methodID, 200);
  2096.    name = UseString(buffer);
  2097.  
  2098.    {
  2099.       OBJECT object2;
  2100.  
  2101.       if (object2 =
  2102.            FindStringInWatchedBinTree(
  2103.               (W_AVLTREE)FindAttribute(parent, ATTR_GUICHILDREN),
  2104.               name))
  2105.       {
  2106.          struct WindowObject *wo;
  2107.  
  2108.          /*
  2109.           * The window is already up top, so pop it on top of all the
  2110.           *  windows.
  2111.           */
  2112.          if (wo = FindAttribute(object2, ATTR_WINDOW))
  2113.             WindowToFront(wo->wo_window);
  2114.  
  2115.          DropObject(object2);
  2116.          QuickDropString(name);
  2117.  
  2118.          /*
  2119.           * Destroy this object.
  2120.           */
  2121.          UseObject(object);
  2122.          DropObject(object);
  2123.          return NULL;
  2124.       }
  2125.    }
  2126.  
  2127.    tag[0].ti_Tag = WA_Width;
  2128.    tag[0].ti_Data = 500;
  2129.    tag[1].ti_Tag = WA_Height;
  2130.    tag[1].ti_Data = 200;
  2131.    tag[2].ti_Tag = WA_MinWidth;
  2132.    tag[2].ti_Data = 60;
  2133.    tag[3].ti_Tag = WA_MinHeight;
  2134.    tag[3].ti_Data = 40;
  2135.    tag[4].ti_Tag = WA_MaxWidth;
  2136.    tag[4].ti_Data = -1;
  2137.    tag[5].ti_Tag = WA_MaxHeight;
  2138.    tag[5].ti_Data = -1;
  2139.    tag[6].ti_Tag = WA_SimpleRefresh;
  2140.    tag[6].ti_Data = TRUE;
  2141.    tag[7].ti_Tag = TAG_END;
  2142.  
  2143.    object = DoJazzMethod(object, class->meta_superClass, MethodID,
  2144.                                               parent,
  2145.                                               name,
  2146.                                               NULL,
  2147.                                               NULL,
  2148.                                               tag, METHOD_END);
  2149.    QuickDropString(name);
  2150.  
  2151.    if (!object)
  2152.       return NULL;
  2153.  
  2154.    mlo = FindAttribute(object, ATTR_LOCALWIN);
  2155.    NewList(&mlo->list);
  2156.  
  2157.    /*
  2158.     * Copy the method-ref (argument or parameter) designations into
  2159.     *  an allocated list.
  2160.     */
  2161.    if (method->mh_num)
  2162.    {
  2163.       METHOD_REF *ref;
  2164.       struct MyNode *nodes;
  2165.  
  2166.       mlo->nodes = AllocVec(sizeof(struct MyNode) * method->mh_num,
  2167.                             MEMF_PUBLIC);
  2168.  
  2169.       nodes = mlo->nodes;
  2170.       buffer[4] = 0;
  2171.       for (ref = method->mh_args; ref->mr_tag; ref++)
  2172.       {
  2173.          *((long *)buffer) = ref->mr_tag;
  2174.          nodes->node.ln_Name = UseString(buffer);
  2175.          nodes->object = ref;
  2176.          AddTail(&mlo->list, nodes);
  2177.          nodes++;
  2178.       }
  2179.  
  2180.    }
  2181.  
  2182.    ng.ng_LeftEdge = ng.ng_TopEdge = 50;
  2183.    ng.ng_Width = 300;
  2184.    ng.ng_Height = 90;
  2185.    ng.ng_Flags = PLACETEXT_ABOVE;
  2186.    tag[0].ti_Tag = GTLV_Labels;
  2187.    tag[0].ti_Data = (ULONG)&mlo->list;
  2188.    tag[1].ti_Tag = TAG_END;
  2189.  
  2190.    strcpy(buffer, "method in class: ");
  2191.    if (mclass)
  2192.       strncat(buffer, mclass->ccl_name, 18);
  2193.    strcat(buffer, "...");
  2194.    name = UseString(buffer);
  2195.    DropObject(CreateInstance(NULL,
  2196.                              GADGTCLASS,
  2197.                              METACLASS,
  2198.                              object,
  2199.                              name,
  2200.                              object,
  2201.                              METHOD_GADGET_SELECT,
  2202.                              &ng,
  2203.                              LISTVIEW_KIND,
  2204.                              tag,
  2205.                              METHOD_END));
  2206.    QuickDropString(name);
  2207.  
  2208.    ng.ng_TopEdge += ng.ng_Height;
  2209.    ng.ng_Height = 15;
  2210.    ng.ng_Width = 80;
  2211.    ng.ng_Flags = PLACETEXT_RIGHT;
  2212.    tag[0].ti_Tag = TAG_END;
  2213.    mlo->object1 = CreateInstance(NULL,
  2214.                                  GADGTCLASS,
  2215.                                  METACLASS,
  2216.                                  object,
  2217.                                  ":size of argument",
  2218.                                  object,
  2219.                                  METHOD_GADGET_SELECT,
  2220.                                  &ng,
  2221.                                  NUMBER_KIND,
  2222.                                  tag,
  2223.                                  METHOD_END);
  2224.  
  2225.    ng.ng_TopEdge += ng.ng_Height;
  2226.    ng.ng_Height = 15;
  2227.    ng.ng_Width = 80;
  2228.    ng.ng_Flags = PLACETEXT_RIGHT;
  2229.    tag[0].ti_Tag = TAG_END;
  2230.    mlo->object2 = CreateInstance(NULL,
  2231.                                  GADGTCLASS,
  2232.                                  METACLASS,
  2233.                                  object,
  2234.                                  NULL,
  2235.                                  object,
  2236.                                  METHOD_GADGET_SELECT,
  2237.                                  &ng,
  2238.                                  TEXT_KIND,
  2239.                                  tag,
  2240.                                  METHOD_END);
  2241.    return object;
  2242. }
  2243.  
  2244. void RefWinDestroyMethod(METHOD_ARGS)
  2245. {
  2246.    struct RWinLocalObjects *mlo;
  2247.    struct Node *node;
  2248.  
  2249.    mlo = FindAttribute(object, ATTR_LOCALWIN);
  2250.    DropObject(mlo->object1);
  2251.    DropObject(mlo->object2);
  2252.    DropString(mlo->text);
  2253.    if (mlo->nodes)
  2254.    {
  2255.       for(node = mlo->list.lh_Head; node->ln_Succ; node = node->ln_Succ)
  2256.          QuickDropString(node->ln_Name);
  2257.  
  2258.       FreeVec(mlo->nodes);
  2259.    }
  2260.    CallSuper();
  2261. }
  2262.  
  2263. /*
  2264.  * A new METHOD_REF has been hit, show the selected argument's information.
  2265.  */
  2266. METHOD_REF REF_RefWinHitMethod[] = {
  2267.                                       'long', sizeof(long), 0,
  2268.                                       TAG_DONE
  2269.                                    };
  2270. void RefWinHitMethod(METHOD_ARGS, long code)
  2271. {
  2272.    struct RWinLocalObjects *mlo;
  2273.    struct TagItem tags[2];
  2274.  
  2275.    mlo = FindAttribute(object, ATTR_LOCALWIN);
  2276.    mlo->lastNode = &mlo->nodes[code];
  2277.  
  2278.    tags[0].ti_Tag = GTNM_Number;
  2279.    tags[0].ti_Data = ((METHOD_REF *)(mlo->lastNode->object))->mr_size;
  2280.    tags[1].ti_Tag = TAG_END;
  2281.  
  2282.    DoJazzMethod(mlo->object1, NULL, METHOD_GADGET_CHANGE, tags, METHOD_END);
  2283.  
  2284.    {
  2285.       char buffer[256];
  2286.  
  2287.       switch(((METHOD_REF *)(mlo->lastNode->object))->mr_tag)
  2288.       {
  2289.          case 'TAGL':
  2290.             RawDoFmt("size of tag item: %d",
  2291.                      &((METHOD_REF *)(mlo->lastNode->object))->mr_flags,
  2292.                      SprintfCallback, buffer);
  2293.             break;
  2294.          case 'JOBJ':
  2295.             switch(((METHOD_REF *)(mlo->lastNode->object))->mr_flags)
  2296.             {
  2297.                case SHADOW_OBJECT:
  2298.                   strcpy(buffer, "Jazz Object");
  2299.                   break;
  2300.                case SHADOW_CLASSLESSOBJECT:
  2301.                   strcpy(buffer, "Jazz Classless");
  2302.                   break;
  2303.                case SHADOW_META:
  2304.                   strcpy(buffer, "Jazz Meta");
  2305.                   break;
  2306.                case SHADOW_CLASS:
  2307.                   strcpy(buffer, "Jazz Class");
  2308.                   break;
  2309.                case SHADOW_CLUSTER:
  2310.                   strcpy(buffer, "Jazz Cluster");
  2311.                   break;
  2312.                case SHADOW_COMPOSITE:
  2313.                   strcpy(buffer, "Jazz Composite");
  2314.                   break;
  2315.                default:
  2316.                   strcpy(buffer, "unknown/unspecified");
  2317.                   break;
  2318.             }
  2319.             break;
  2320.          case 'JSTR':
  2321.             strcpy(buffer, "String");
  2322.             break;
  2323.          default:
  2324.             RawDoFmt("size of pointer? : %d",
  2325.                      &((METHOD_REF *)(mlo->lastNode->object))->mr_flags,
  2326.                      SprintfCallback, buffer);
  2327.       }
  2328.  
  2329.       DropString(mlo->text);
  2330.       mlo->text = UseString(buffer);
  2331.    }
  2332.  
  2333.    tags[0].ti_Tag = GTTX_Text;
  2334.    tags[0].ti_Data = (ULONG)mlo->text;
  2335.    DoJazzMethod(mlo->object2, NULL, METHOD_GADGET_CHANGE, tags, METHOD_END);
  2336.  
  2337. }
  2338.